Please stop using Stack class in Java. Here (leetcode.com/problems/flatten-nested-list-iterator/discuss/80147/Simple-Java-solution-using-a-stack-with-explanation/165585) you can find a great explanation of why it's a bad idea and it might even cost you an offer.
There's an unhealthy obsession with Stack and LinkedList classes on Leetcode - 2 classes that nobody uses in real life.

why we can not just use insert method to creat a new BST, which is the answer?

In approach 2, the use of the lower bound is not necessary at all. Surprised the author dares to write "It's quite obvious that the best possible time complexity for this problem is O(N) " but does not realize the "obvious" facts that:

1. we have a BST
2. we have a preorder of that BST

Meaning that because you are going left first by default tree traversal pattern, then you are guaranteed to have placed the least element first. So only need to check the upper limit.

class Solution {
  int idx = 0;
  int[] preorder;
  int n;

  public TreeNode helper(int upper) {
    // if all elements from preorder are used
    // then the tree is constructed
    if (idx == n) return null;

    int val = preorder[idx];
    // if the current element 
    // couldn't be placed here to meet BST requirements
    if (val > upper) return null;

    // place the current element
    // and recursively construct subtrees
    idx++;
    TreeNode root = new TreeNode(val);
    root.left = helper(val);
    root.right = helper(upper);
    return root;
  }

  public TreeNode bstFromPreorder(int[] preorder) {
    this.preorder = preorder;
    n = preorder.length;
    return helper(Integer.MAX_VALUE);
  }
}

"obvious" .... smh...

not really

@andvary @liaison How come space complexity for Solution 3 is O(N)? While adding any new node, we might have to pop logN amount of node. Doesn't that make it O(NlogN)?

Recall the basic question of BST, #701 Insert into a Binary Search Tree

Here was my 1st attempt in python

"""
1st: recursion
    - reuse lc701: Insert into a Binary Search Tree
    - for each element in the array
    - do lc701

    Time    from O(N) to O(NlogN), because the number of nodes of result tree < N during the construction of it
    Space   O(N)
    12 ms, faster than 99.45%
"""
class Solution(object):
    def bstFromPreorder(self, preorder):
        res = None
        for x in preorder:
            res = self.insertIntoBST(res, x)
        return res
    def insertIntoBST(self, root, val):
        if root == None:
            return TreeNode(val)
        if val < root.val:
            root.left = self.insertIntoBST(root.left, val)
        else:
            root.right = self.insertIntoBST(root.right, val)
        return root

Here was my second attempt with iteration

"""
    2nd: same concept but with iteration
    - reuse lc701: Insert into a Binary Search Tree
    - for each element in the array
    - do lc701

    Time    from O(N) to O(NlogN), because the number of nodes of result tree < N during the construction of it
    Space   O(N)
    20 ms, faster than 84.85%
"""
class Solution(object):
    def bstFromPreorder(self, preorder):
        res = None
        for x in preorder:
            res = self.insertIntoBST(res, x)
        return res

    def insertIntoBST(self, root, val):
        if root == None:
            return TreeNode(val)
        cur = root
        while True:
            if cur.val < val:
                if cur.right != None:
                    cur = cur.right
                else:
                    cur.right = TreeNode(val)
                    break
            else:
                if cur.left != None:
                    cur = cur.left
                else:
                    cur.left = TreeNode(val)
                    break
        return root

Isn't it a bit overcomplicated of approach 1 to just get a O(NlogN) solution?

We can easily get a O(NlogN) solution with this:

class Solution {
public:
    TreeNode* bstFromPreorder(vector<int>& preorder) {
        return helper(preorder,0,preorder.size()-1);
    }
    
    TreeNode* helper(vector<int>& preorder, int i, int j)
    {
        if(i>j) return nullptr;
        if(i==j) return new TreeNode(preorder[i]);
        
        TreeNode* root=new TreeNode(preorder[i]);
        
        int k=i+1;
        while(k<=j && preorder[k]<preorder[i]) k++;
        root->left=helper(preorder,i+1,k-1);
        root->right=helper(preorder,k,j);
        return root;
    }
};

In approach 2 we don't need to track lower and upper. We can only keep track of the upper. I stand to be corrected but this is what I did and it worked. The code is in Javascript:

var bstFromPreorder = function(preorder) {
    let i = 0
    
    function dfs(max){
        if(i == preorder.length) return null
        if(preorder[i] >= max) return null
        let root = new TreeNode(preorder[i])
        i++
        root.left = dfs(root.val)
        root.right = dfs(max)
        return root
    }
    return dfs(10e9)
};

https://leetcode.com/articles/construct-binary-tree-from-preorder-and-inorder-tr/ link is not working.

Approach 3 solution and animation is really good. Helps you understand in a very simple way. Thanks! :)

Can someone explain how the complexity is O(N) for the third solution? To insert 10, for example, the code will pop 7 & 5 and thus it will do logN work. So the order should be O(NlogN) in worst case, right?